diff --git a/system/database/DB_query_builder.php b/system/database/DB_query_builder.php
index 085c615..69dc8c2 100644
--- a/system/database/DB_query_builder.php
+++ b/system/database/DB_query_builder.php
@@ -661,6 +661,15 @@
 				// value appears not to have been set, assign the test to IS NULL
 				$k .= ' IS NULL';
 			}
+			else
+			{
+				$operator = trim($this->_get_operator($k));
+
+				if ($operator === '<>' OR $operator === '!=')
+				{
+					$k = str_replace($operator, ' IS NOT NULL', $k);
+				}
+			}
 
 			$this->{$qb_key}[] = array('condition' => $prefix.$k.$v, 'escape' => $escape);
 			if ($this->qb_caching === TRUE)
diff --git a/user_guide_src/source/changelog.rst b/user_guide_src/source/changelog.rst
index c4360aa..6619ae9 100644
--- a/user_guide_src/source/changelog.rst
+++ b/user_guide_src/source/changelog.rst
@@ -187,6 +187,7 @@
       - Changed ``limit()`` to ignore NULL values instead of always casting to integer.
       - Changed ``offset()`` to ignore empty values instead of always casting to integer.
       - Methods ``insert_batch()`` and ``update_batch()`` now return an integer representing the number of rows affected by them.
+      - Methods ``where()``, ``or_where()``, ``having()`` and ``or_having()`` now convert the operators *<>* and *!=* into *IS NOT NULL* when the supplied for comparison value is equal to *NULL*. 
 
    -  :doc:`Database Results <database/results>` changes include:
 
